home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / utils / adt / float.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  19.2 KB  |  1,193 lines
  1. /*
  2.  * float.c --
  3.  *      Functions for the built-in floating-point types.
  4.  *
  5.  *    Basic float4 ops:
  6.  *      float4in, float4inAd, float4out, float4outAd, float4abs, float4um
  7.  *    Basic float8 ops:
  8.  *     float8in, float8inAd, float8out, float8outAd, float8abs, float8um
  9.  *    Arithmetic operators:
  10.  *     float4pl, float4mi, float4mul, float4div
  11.  *     float8pl, float8mi, float8mul, float8div
  12.  *    Comparison operators:
  13.  *     float4eq, float4ne, float4lt, float4le, float4gt, float4ge
  14.  *     float8eq, float8ne, float8lt, float8le, float8gt, float8ge
  15.  *    Conversion routines:
  16.  *     ftod, dtof
  17.  *
  18.  *    Random float8 ops:
  19.  *      dround, dtrunc, dsqrt, dcbrt, dpow, dexp, dlog1
  20.  *    Arithmetic operators:
  21.  *     float48pl, float48mi, float48mul, float48div
  22.  *     float84pl, float84mi, float84mul, float84div
  23.  *    Comparison operators:
  24.  *     float48eq, float48ne, float48lt, float48le, float48gt, float48ge
  25.  *     float84eq, float84ne, float84lt, float84le, float84gt, float84ge
  26.  *
  27.  *    (You can do the arithmetic and comparison stuff using conversion
  28.  *     routines, but then you pay the overhead of converting...)
  29.  */
  30.  
  31. #include <strings.h>
  32. #include <ctype.h>
  33. #include <math.h>
  34.  
  35. #include "tmp/postgres.h"
  36. #include "utils/fmgr.h"
  37. #include "utils/builtins.h"    /* for ftod() prototype */
  38. #include "utils/log.h"
  39.  
  40. RcsId("$Header: /private/postgres/src/utils/adt/RCS/float.c,v 1.14 1992/08/16 03:41:41 mer Exp $");
  41.  
  42.  
  43. #define FORMAT         'e'    /* use "E" output format as standard format */
  44. #define    MAXFLOATWIDTH     12    /* "n.nnnnnE+nn\0" format */
  45. #define FLOATPRECISION    5      /* number of significant digits */
  46.                 /*    after decimal point */
  47. #define MAXDOUBLEWIDTH    24    /* "n.nnnnnnnnnnnnnnnnnE+nn\0" format */
  48. #define DOUBLEPRECISION    17    /* number of significant digits */
  49.                 /*    after decimal point */
  50.  
  51. extern double    atof();
  52. extern double   cbrt();
  53.  
  54.  
  55. char *float8outAd ARGS((float64 num , int precision , char format ));
  56. float64 float8inAd ARGS((char *num ));
  57. char *float4outAd ARGS((float32 num , int precision , char format ));
  58. float32 float4inAd ARGS((char *num ));
  59.  
  60.         /* ========== USER I/O ROUTINES ========== */
  61.  
  62.  
  63. /*
  64.  *    float4in    - converts "num" to float
  65.  *              restricted syntax:
  66.  *              {<sp>} [+|-] {digit} [.{digit}] [<exp>]
  67.  *              where <sp> is a space, digit is 0-9,
  68.  *              <exp> is "e" or "E" followed by an integer.
  69.  */
  70. float32
  71. float4in(num)
  72.     char    *num;
  73. {
  74.     float32    result = (float32) palloc(sizeof(float32data));
  75.     
  76.     *result = (float32data) atof(num);
  77.     return(result);
  78. }
  79.  
  80.  
  81. /*
  82.  *    float4inAd    - advanced float4in, converts "num" to float4,
  83.  *              extended syntax:
  84.  *             {<sp>}[+|-]{<sp>}{<digit>}[.{digit}]{<sp>}[<exp>]
  85.  *             where <exp> is "e" or "E" followed by an integer, 
  86.  *             <sp> is a space character, <digit> is zero through 
  87.  *             nine, [] is zero or one, and {} is zero or more.
  88.  *
  89.  *             uses atof1, code of ingres; file atof1.c
  90.  */
  91. float32
  92. float4inAd(num)
  93.     char    *num;
  94. {
  95.     float64data    val;
  96.     float32        result = (float32) palloc(sizeof(float32data));
  97.     int    status;
  98.     
  99.     status=atof1(num,&val);
  100.     if (status==0) {
  101.         *result = val;
  102.         return(result);
  103.     }
  104.     if (status==-1) 
  105.         printf("\tSyntax error\n");
  106.     if (status==1) 
  107.         printf("\tOverflow\n");
  108.     *result = val;
  109.     return(result);
  110. }
  111.  
  112.  
  113. /*
  114.  *    float4out    - converts a float4 number to a string
  115.  *              using a standard output format
  116.  */
  117. char *
  118. float4out(num)
  119.     float32    num;
  120. {
  121.     
  122.     char    *ascii = (char *)palloc(MAXFLOATWIDTH+1);    
  123.     
  124.     if (!num)
  125.         return strcpy(ascii, "(null)");
  126.  
  127.     ftoa((double) *num, ascii, MAXFLOATWIDTH, FLOATPRECISION, FORMAT);
  128.     return(ascii);
  129. }
  130.  
  131.  
  132. /*    float4outAd    - converts a float4 number to a string
  133.  *              allowing to specify the output format
  134.  *
  135.  *    'format' can be:
  136.  *        e or E:  "E" format output
  137.  *        f or F:  "F" format output
  138.  *        g or G:  "F" format output if it will fit, otherwise
  139.  *             use "E" format.
  140.  *        n or N:  same as G, but decimal points will not always
  141.  *             be aligned.
  142.  *
  143.  *    'precision' is the number of digits after decimal point.
  144.  */
  145. char *
  146. float4outAd(num, precision, format)
  147.     float32    num;
  148.     int    precision;
  149.     char    format;
  150. {
  151.     char    *ascii = (char *)palloc(MAXFLOATWIDTH);    
  152.  
  153.     if (!num)
  154.         return strcpy(ascii, "(null)");
  155.  
  156.     ftoa(*num, ascii, MAXFLOATWIDTH, precision, format);
  157.     return(ascii);
  158. }
  159.  
  160.  
  161. /*
  162.  *    float8in    - converts "num" to float8
  163.  *              restricted syntax:
  164.  *              {<sp>} [+|-] {digit} [.{digit}] [<exp>]
  165.  *              where <sp> is a space, digit is 0-9,
  166.  *              <exp> is "e" or "E" followed by an integer.
  167.  */
  168. float64
  169. float8in(num)
  170.     char    *num;
  171. {
  172.     float64    result = (float64) palloc(sizeof(float64data));
  173.     
  174.     *result = (float64data) atof(num);
  175.     return(result);
  176. }
  177.  
  178.  
  179. /*
  180.  *    float8inAd    - advanced float8in, converts "num" to float8,
  181.  *              extended syntax:
  182.  *             {<sp>}[+|-]{<sp>}{<digit>}[.{digit}]{<sp>}[<exp>]
  183.  *             where <exp> is "e" or "E" followed by an integer, 
  184.  *             <sp> is a space character, <digit> is zero through 
  185.  *             nine, [] is zero or one, and {} is zero or more.
  186.  *
  187.  */
  188. float64
  189. float8inAd(num)
  190.     char    *num;
  191. {
  192.     float64data    val;
  193.     float64    result = (float64) palloc(sizeof(float64data));
  194.     int    status;
  195.     
  196.     status = atof1(num,&val);
  197.     if (status==0) {
  198.         *result = val;
  199.         return(result);
  200.     }
  201.     if (status == -1)
  202.         elog(WARN, "Bad float8 constant");
  203.     if (status == 1)
  204.         elog(WARN, "float8 overflow");
  205.     *result = val;
  206.     return(result);
  207. }
  208.  
  209.  
  210. /*
  211.  *    float8out    - converts float8 number to a string
  212.  *              using a standard output format
  213.  */
  214. char *
  215. float8out(num)
  216.     float64    num;
  217. {
  218.     char    *ascii = (char *)palloc(MAXDOUBLEWIDTH+1);
  219.  
  220.     if (!num)
  221.         return strcpy(ascii, "(null)");
  222.  
  223.     ftoa(*num, ascii, MAXDOUBLEWIDTH, DOUBLEPRECISION, FORMAT);
  224.     return(ascii);
  225. }
  226.  
  227.  
  228. /*
  229.  *    float8outAd    - advanced float8out, converts float8 number to a
  230.  *              string allowing to specify the output format
  231.  *
  232.  *    'format' can be:
  233.  *        e or E:  "E" format output
  234.  *        f or F:  "F" format output
  235.  *        g or G:  "F" format output if it will fit, otherwise
  236.  *             use "E" format.
  237.  *        n or N:  same as G, but decimal points will not always
  238.  *             be aligned.
  239.  *
  240.  *    'precision' is the number of digits after decimal point.
  241.  */
  242. char *
  243. float8outAd(num, precision, format)
  244.     float64    num;
  245.     int    precision;
  246.     char    format;
  247. {
  248.     char    *ascii = (char *)palloc(MAXDOUBLEWIDTH);
  249.     
  250.     if (!num)
  251.         return strcpy(ascii, "(null)");
  252.  
  253.     ftoa(*num, ascii, MAXDOUBLEWIDTH, precision, format);
  254.     return(ascii);
  255. }
  256.  
  257.  
  258.          /* ========== PUBLIC ROUTINES ========== */
  259.  
  260.  
  261. /*
  262.  *    ======================
  263.  *    FLOAT4 BASE OPERATIONS
  264.  *    ======================
  265.  */
  266.  
  267. /*
  268.  *    float4abs    - returns a pointer to |arg1| (absolute value)
  269.  */
  270. float32
  271. float4abs(arg1)
  272.     float32    arg1;
  273. {
  274.     float64    dblarg1;
  275.     float32    result;
  276.     
  277.     if (!arg1)
  278.         return (float32)NULL;
  279.  
  280.     dblarg1 = ftod(arg1);
  281.     result = (float32) palloc(sizeof(float32data));
  282.  
  283.     *result = (float32data) fabs(*dblarg1);
  284.     return(result);
  285. }
  286.  
  287. /*
  288.  *    float4um     - returns a pointer to -arg1 (unary minus)
  289.  */
  290. float32
  291. float4um(arg1)
  292.     float32    arg1;
  293. {
  294.     float32    result;
  295.     
  296.     if (!arg1)
  297.         return (float32)NULL;
  298.  
  299.     result = (float32) palloc(sizeof(float32data));
  300.  
  301.     *result = -(*arg1);
  302.     return(result);
  303. }
  304.  
  305. float32
  306. float4larger(arg1, arg2)
  307.     float32 arg1;
  308.     float32 arg2;
  309. {
  310.     float32    result;
  311.  
  312.     if (!arg1 || !arg2)
  313.         return (float32)NULL;
  314.  
  315.     result = (float32) palloc(sizeof(float32data));
  316.  
  317.     *result = ((*arg1 > *arg2) ? *arg1 : *arg2);
  318.     return result;
  319. }
  320.  
  321. float32
  322. float4smaller(arg1, arg2)
  323.     float32 arg1;
  324.     float32 arg2;
  325. {
  326.     float32    result;
  327.  
  328.     if (!arg1 || !arg2)
  329.         return (float32)NULL;
  330.  
  331.     result = (float32) palloc(sizeof(float32data));
  332.  
  333.     *result = ((*arg1 > *arg2) ? *arg2 : *arg1);
  334.     return result;
  335. }
  336.  
  337. /*
  338.  *    ======================
  339.  *    FLOAT8 BASE OPERATIONS
  340.  *    ======================
  341.  */
  342.  
  343. /*
  344.  *    float8abs    - returns a pointer to |arg1| (absolute value)
  345.  */
  346. float64
  347. float8abs(arg1)
  348.      float64    arg1;
  349. {
  350.     float64    result;
  351.     
  352.     if (!arg1)
  353.         return (float64)NULL;
  354.  
  355.     result = (float64) palloc(sizeof(float64data));
  356.  
  357.     *result = fabs(*arg1);
  358.     return(result);
  359. }
  360.  
  361.  
  362. /*
  363.  *    float8um    - returns a pointer to -arg1 (unary minus)
  364.  */
  365. float64
  366. float8um(arg1)
  367.     float64    arg1;
  368. {
  369.     float64    result;
  370.     
  371.     if (!arg1)
  372.         return (float64)NULL;
  373.  
  374.     result = (float64) palloc(sizeof(float64data));
  375.  
  376.     *result = -(*arg1);
  377.     return(result);
  378. }
  379.  
  380. float64
  381. float8larger(arg1, arg2)
  382.     float64 arg1;
  383.     float64 arg2;
  384. {
  385.     float64    result;
  386.  
  387.     if (!arg1 || !arg2)
  388.         return (float64)NULL;
  389.  
  390.     result = (float64) palloc(sizeof(float64data));
  391.  
  392.     *result = ((*arg1 > *arg2) ? *arg1 : *arg2);
  393.     return result;
  394. }
  395.  
  396. float64
  397. float8smaller(arg1, arg2)
  398.     float64 arg1;
  399.     float64 arg2;
  400. {
  401.     float64    result;
  402.  
  403.     if (!arg1 || !arg2)
  404.         return (float64)NULL;
  405.  
  406.     result = (float64) palloc(sizeof(float64data));
  407.  
  408.     *result = ((*arg1 > *arg2) ? *arg2 : *arg1);
  409.     return result;
  410. }
  411.  
  412.  
  413. /*
  414.  *    ====================
  415.  *    ARITHMETIC OPERATORS
  416.  *    ====================
  417.  */
  418.  
  419. /*
  420.  *    float4pl    - returns a pointer to arg1 + arg2
  421.  *    float4mi    - returns a pointer to arg1 - arg2
  422.  *    float4mul    - returns a pointer to arg1 * arg2
  423.  *    float4div    - returns a pointer to arg1 / arg2
  424.  *    float4inc    - returns a poniter to arg1 + 1.0
  425.  */
  426. float32 
  427. float4pl(arg1, arg2)
  428.     float32    arg1, arg2;
  429. {
  430.     float32    result;
  431.  
  432.     if (!arg1 || !arg2)
  433.         return (float32)NULL;
  434.  
  435.     result = (float32) palloc(sizeof(float32data));
  436.  
  437.     *result = *arg1 + *arg2;
  438.     return(result);
  439. }
  440.  
  441. float32
  442. float4mi(arg1, arg2)
  443.     float32    arg1, arg2;
  444. {
  445.     float32    result;
  446.  
  447.     if (!arg1 || !arg2)
  448.         return (float32)NULL;
  449.  
  450.     result = (float32) palloc(sizeof(float32data));
  451.  
  452.     *result = *arg1 - *arg2;
  453.     return(result);
  454. }
  455.  
  456. float32
  457. float4mul(arg1, arg2)
  458.     float32    arg1, arg2;
  459. {
  460.     
  461.     float32    result;
  462.  
  463.     if (!arg1 || !arg2)
  464.         return (float32)NULL;
  465.  
  466.     result = (float32) palloc(sizeof(float32data));
  467.  
  468.     *result = *arg1 * *arg2;
  469.     return(result);
  470. }
  471.  
  472. float32
  473. float4div(arg1, arg2)
  474.     float32    arg1, arg2;
  475. {
  476.     float32    result;
  477.  
  478.     if (!arg1 || !arg2)
  479.         return (float32)NULL;
  480.  
  481.     result = (float32) palloc(sizeof(float32data));
  482.  
  483.     *result = *arg1 / *arg2;
  484.     return(result);
  485. }
  486.  
  487. float32
  488. float4inc(arg1)
  489.     float32 arg1;
  490. {
  491.     if (!arg1)
  492.         return (float32)NULL;
  493.  
  494.     *arg1 = *arg1 + (float32data)1.0;
  495.     return arg1;
  496. }
  497.  
  498. /*
  499.  *    float8pl    - returns a pointer to arg1 + arg2
  500.  *    float8mi    - returns a pointer to arg1 - arg2
  501.  *    float8mul    - returns a pointer to arg1 * arg2
  502.  *    float8div    - returns a pointer to arg1 / arg2
  503.  *    float8inc    - returns a pointer to arg1 + 1.0
  504.  */
  505. float64 
  506. float8pl(arg1, arg2)
  507.     float64    arg1, arg2;
  508. {
  509.     float64    result;
  510.  
  511.     if (!arg1 || !arg2)
  512.         return (float64)NULL;
  513.  
  514.     result = (float64) palloc(sizeof(float64data));
  515.  
  516.     *result = *arg1 + *arg2;
  517.     return(result);
  518. }
  519.  
  520. float64
  521. float8mi(arg1, arg2)
  522.     float64    arg1, arg2;
  523. {
  524.     float64    result;
  525.  
  526.     if (!arg1 || !arg2)
  527.         return (float64)NULL;
  528.  
  529.     result = (float64) palloc(sizeof(float64data));
  530.  
  531.     *result = *arg1 - *arg2;
  532.     return(result);
  533. }
  534.  
  535. float64
  536. float8mul(arg1, arg2)
  537.     float64    arg1, arg2;
  538. {
  539.     float64    result;
  540.  
  541.     if (!arg1 || !arg2)
  542.         return (float64)NULL;
  543.  
  544.     result = (float64) palloc(sizeof(float64data));
  545.  
  546.     *result = *arg1 * *arg2;
  547.     return(result);
  548. }
  549.  
  550. float64
  551. float8div(arg1, arg2)
  552.     float64    arg1, arg2;
  553. {
  554.     float64    result;
  555.  
  556.     if (!arg1 || !arg2)
  557.         return (float64)NULL;
  558.  
  559.     result = (float64) palloc(sizeof(float64data));
  560.  
  561.     *result = *arg1 / *arg2;
  562.     return(result);
  563. }
  564.  
  565. float64
  566. float8inc(arg1)
  567.     float64    arg1;
  568. {
  569.     if (!arg1)
  570.         return (float64)NULL;
  571.  
  572.     *arg1 = *arg1 + (float64data)1.0;
  573.     return(arg1);
  574. }
  575.  
  576.  
  577. /*
  578.  *    ====================
  579.  *    COMPARISON OPERATORS
  580.  *    ====================
  581.  */
  582.  
  583. /*
  584.  *    float4{eq,ne,lt,le,gt,ge}    - float4/float4 comparison operations
  585.  */
  586. long
  587. float4eq(arg1, arg2)
  588.     float32    arg1, arg2;
  589. {
  590.     if (!arg1 || !arg2)
  591.         return (long)NULL;
  592.  
  593.     return(*arg1 == *arg2);
  594. }
  595.  
  596. long
  597. float4ne(arg1, arg2)
  598.     float32    arg1, arg2;
  599. {
  600.     if (!arg1 || !arg2)
  601.         return (long)NULL;
  602.  
  603.     return(*arg1 != *arg2);
  604. }
  605.  
  606. long
  607. float4lt(arg1, arg2)
  608.     float32    arg1, arg2;
  609. {
  610.     if (!arg1 || !arg2)
  611.         return (long)NULL;
  612.  
  613.     return(*arg1 < *arg2);
  614. }
  615.  
  616. long
  617. float4le(arg1, arg2)
  618.     float32    arg1, arg2;
  619. {
  620.     if (!arg1 || !arg2)
  621.         return (long)NULL;
  622.  
  623.     return(*arg1 <= *arg2);
  624. }
  625.  
  626. long
  627. float4gt(arg1, arg2)
  628.     float32    arg1, arg2;
  629. {
  630.     if (!arg1 || !arg2)
  631.         return (long)NULL;
  632.  
  633.     return(*arg1 > *arg2);
  634. }
  635.  
  636. long
  637. float4ge(arg1, arg2)
  638.     float32    arg1, arg2;
  639. {
  640.     if (!arg1 || !arg2)
  641.         return (long)NULL;
  642.  
  643.     return(*arg1 >= *arg2);
  644. }
  645.  
  646. /*
  647.  *    float8{eq,ne,lt,le,gt,ge}    - float8/float8 comparison operations
  648.  */
  649. long
  650. float8eq(arg1, arg2)
  651.     float64    arg1, arg2;
  652. {
  653.     if (!arg1 || !arg2)
  654.         return (long)NULL;
  655.  
  656.     return(*arg1 == *arg2);
  657. }
  658.  
  659. long
  660. float8ne(arg1, arg2)
  661.     float64    arg1, arg2;
  662. {
  663.     if (!arg1 || !arg2)
  664.         return (long)NULL;
  665.  
  666.     return(*arg1 != *arg2);
  667. }
  668.  
  669. long
  670. float8lt(arg1, arg2)
  671.     float64    arg1, arg2;
  672. {
  673.     if (!arg1 || !arg2)
  674.         return (long)NULL;
  675.  
  676.     return(*arg1 < *arg2);
  677. }
  678.  
  679. long
  680. float8le(arg1, arg2)
  681.     float64    arg1, arg2;
  682. {
  683.     if (!arg1 || !arg2)
  684.         return (long)NULL;
  685.  
  686.     return(*arg1 <= *arg2);
  687. }
  688.  
  689. long
  690. float8gt(arg1, arg2)
  691.     float64    arg1, arg2;
  692. {
  693.     if (!arg1 || !arg2)
  694.         return (long)NULL;
  695.  
  696.     return(*arg1 > *arg2);
  697. }
  698.  
  699. long
  700. float8ge(arg1, arg2)
  701.     float64    arg1, arg2;
  702. {
  703.     if (!arg1 || !arg2)
  704.         return (long)NULL;
  705.  
  706.     return(*arg1 >= *arg2);
  707. }
  708.  
  709.  
  710. /*
  711.  *    ===================
  712.  *    CONVERSION ROUTINES
  713.  *    ===================
  714.  */
  715.  
  716. /*
  717.  *    ftod        - converts a float4 number to a float8 number
  718.  */
  719. float64
  720. ftod(num)
  721.     float32    num;
  722. {
  723.     float64    result;
  724.     
  725.     if (!num)
  726.         return (float64)NULL;
  727.  
  728.     result = (float64) palloc(sizeof(float64data));
  729.  
  730.     *result = *num;
  731.     return(result);
  732. }
  733.  
  734.  
  735. /*
  736.  *    dtof        - converts a float8 number to a float4 number
  737.  */
  738. float32
  739. dtof(num)
  740.     float64    num;
  741. {
  742.     float32    result;
  743.     
  744.     if (!num)
  745.         return (float32)NULL;
  746.  
  747.     result = (float32) palloc(sizeof(float32data));
  748.  
  749.     *result = *num;
  750.     return(result);
  751. }
  752.  
  753.  
  754. /*
  755.  *    =======================
  756.  *    RANDOM FLOAT8 OPERATORS
  757.  *    =======================
  758.  */
  759.  
  760. /*
  761.  *    dround        - returns a pointer to  ROUND(arg1)
  762.  */
  763. float64
  764. dround(arg1)
  765.     float64    arg1;
  766. {
  767.     float64    result = (float64) palloc(sizeof(float64data));
  768.     double rint();
  769.  
  770.     *result = (float64data) rint((double) *arg1);
  771.     return(result);
  772. }
  773.  
  774.  
  775. /*
  776.  *    dtrunc        - returns a pointer to  truncation of arg1,
  777.  *              arg1 >= 0 ... the greatest integer as float8 less 
  778.  *                    than or equal to arg1
  779.  *              arg1 < 0  ...    the greatest integer as float8 greater
  780.  *                    than or equal to arg1
  781.  */
  782. float64
  783. dtrunc(arg1)
  784.      float64    arg1;
  785. {
  786.     float64    result;
  787.  
  788.     if (!arg1)
  789.         return (float64)NULL;
  790.  
  791.     result = (float64) palloc(sizeof(float64data));
  792.  
  793.     if (*arg1 > 0)
  794.         *result = (float64data) floor((double) *arg1);
  795.     else
  796.         *result = (float64data) -(floor((double) -(*arg1)));
  797.     return(result);
  798. }
  799.  
  800.  
  801. /*    
  802.  *    dsqrt        - returns a pointer to square root of arg1
  803.  */
  804. float64
  805. dsqrt(arg1)
  806.     float64    arg1;
  807. {
  808.     float64    result;
  809.  
  810.     if (!arg1)
  811.         return (float64)NULL;
  812.  
  813.     result = (float64) palloc(sizeof(float64data));
  814.  
  815.     *result = (float64data) sqrt((double) *arg1);
  816.     return (result);
  817. }
  818.  
  819.  
  820. /*
  821.  *    dcbrt        - returns a pointer to cube root of arg1    
  822.  */
  823. float64
  824. dcbrt(arg1)
  825.     float64    arg1;
  826. {
  827.     float64    result;
  828.  
  829.     if (!arg1)
  830.         return (float64)NULL;
  831.  
  832.     result = (float64) palloc(sizeof(float64data));
  833.  
  834.     *result = (float64data) cbrt((double) *arg1);
  835.     return(result);
  836. }
  837.  
  838.  
  839. /*
  840.  *    dpow        - returns a pointer to pow(arg1,arg2)
  841.  */
  842. float64
  843. dpow(arg1, arg2)
  844.     float64    arg1, arg2;
  845. {
  846.     float64    result;
  847.  
  848.     if (!arg1 || !arg2)
  849.         return (float64)NULL;
  850.  
  851.     result = (float64) palloc(sizeof(float64data));
  852.  
  853.     *result = (float64data) pow((double) *arg1, (double) *arg2);
  854.     return(result);
  855. }
  856.  
  857.  
  858. /*
  859.  *    dexp        - returns a pointer to the exponential function of arg1
  860.  */
  861. float64
  862. dexp(arg1)
  863.      float64    arg1;
  864. {
  865.     float64    result;
  866.  
  867.     if (!arg1)
  868.         return (float64)NULL;
  869.  
  870.     result = (float64) palloc(sizeof(float64data));
  871.  
  872.     *result = (float64data) exp((double) *arg1);
  873.     return(result);
  874. }
  875.  
  876.  
  877. /*
  878.  *    dlog1        - returns a pointer to the natural logarithm of arg1
  879.  *              ("dlog" is already a logging routine...)
  880.  */
  881. float64
  882. dlog1(arg1)
  883.     float64    arg1;
  884. {
  885.     float64    result;
  886.  
  887.     if (!arg1)
  888.         return (float64)NULL;
  889.  
  890.     result = (float64) palloc(sizeof(float64data));
  891.  
  892.     *result = (float64data) log((double) *arg1);
  893.     return(result);
  894. }
  895.  
  896.  
  897. /*
  898.  *    ====================
  899.  *    ARITHMETIC OPERATORS
  900.  *    ====================
  901.  */
  902.  
  903. /*
  904.  *    float48pl    - returns a pointer to arg1 + arg2
  905.  *    float48mi    - returns a pointer to arg1 - arg2
  906.  *    float48mul    - returns a pointer to arg1 * arg2
  907.  *    float48div    - returns a pointer to arg1 / arg2
  908.  */
  909. float64 
  910. float48pl(arg1, arg2)
  911.     float32    arg1;
  912.     float64    arg2;
  913. {
  914.     float64    result;
  915.  
  916.     if (!arg1 || !arg2)
  917.         return (float64)NULL;
  918.  
  919.     result = (float64) palloc(sizeof(float64data));
  920.  
  921.     *result = *arg1 + *arg2;
  922.     return(result);
  923. }
  924.  
  925. float64
  926. float48mi(arg1, arg2)
  927.     float32    arg1;
  928.     float64    arg2;
  929. {
  930.     float64    result;
  931.  
  932.     if (!arg1 || !arg2)
  933.         return (float64)NULL;
  934.  
  935.     result = (float64) palloc(sizeof(float64data));
  936.  
  937.     *result = *arg1 - *arg2;
  938.     return(result);
  939. }
  940.  
  941. float64
  942. float48mul(arg1, arg2)
  943.     float32    arg1;
  944.     float64    arg2;
  945. {
  946.     float64    result;
  947.  
  948.     if (!arg1 || !arg2)
  949.         return (float64)NULL;
  950.  
  951.     result = (float64) palloc(sizeof(float64data));
  952.  
  953.     *result = *arg1 * *arg2;
  954.     return(result);
  955. }
  956.  
  957. float64
  958. float48div(arg1, arg2)
  959.     float32    arg1;
  960.     float64    arg2;
  961. {
  962.     float64    result;
  963.     
  964.     if (!arg1 || !arg2)
  965.         return (float64)NULL;
  966.  
  967.     result = (float64) palloc(sizeof(float64data));
  968.  
  969.     *result = *arg1 / *arg2;
  970.     return(result);
  971. }
  972.  
  973. /*
  974.  *    float84pl    - returns a pointer to arg1 + arg2
  975.  *    float84mi    - returns a pointer to arg1 - arg2
  976.  *    float84mul    - returns a pointer to arg1 * arg2
  977.  *    float84div    - returns a pointer to arg1 / arg2
  978.  */
  979. float64 
  980. float84pl(arg1, arg2)
  981.     float64    arg1;
  982.     float32    arg2;
  983. {
  984.     float64    result;
  985.  
  986.     if (!arg1 || !arg2)
  987.         return (float64)NULL;
  988.  
  989.     result = (float64) palloc(sizeof(float64data));
  990.  
  991.     *result = *arg1 + *arg2;
  992.     return(result);
  993. }
  994.  
  995. float64
  996. float84mi(arg1, arg2)
  997.     float64    arg1;
  998.     float32    arg2;
  999. {
  1000.     float64    result;
  1001.  
  1002.     if (!arg1 || !arg2)
  1003.         return (float64)NULL;
  1004.  
  1005.     result = (float64) palloc(sizeof(float64data));
  1006.  
  1007.     *result = *arg1 - *arg2;
  1008.     return(result);
  1009. }
  1010.  
  1011. float64
  1012. float84mul(arg1, arg2)
  1013.     float64    arg1;
  1014.     float32    arg2;
  1015. {
  1016.     
  1017.     float64    result;
  1018.  
  1019.     if (!arg1 || !arg2)
  1020.         return (float64)NULL;
  1021.  
  1022.     result = (float64) palloc(sizeof(float64data));
  1023.  
  1024.     *result = *arg1 * *arg2;
  1025.     return(result);
  1026. }
  1027.  
  1028. float64
  1029. float84div(arg1, arg2)
  1030.     float64    arg1;
  1031.     float32    arg2;
  1032. {
  1033.     float64    result;
  1034.  
  1035.     if (!arg1 || !arg2)
  1036.         return (float64)NULL;
  1037.  
  1038.     result = (float64) palloc(sizeof(float64data));
  1039.  
  1040.     *result = *arg1 / *arg2;
  1041.     return(result);
  1042. }
  1043.  
  1044. /*
  1045.  *    ====================
  1046.  *    COMPARISON OPERATORS
  1047.  *    ====================
  1048.  */
  1049.  
  1050. /*
  1051.  *    float48{eq,ne,lt,le,gt,ge}    - float4/float8 comparison operations
  1052.  */
  1053. long
  1054. float48eq(arg1, arg2)
  1055.     float32    arg1;
  1056.     float64    arg2;
  1057. {
  1058.     if (!arg1 || !arg2)
  1059.         return (long)NULL;
  1060.  
  1061.     return(*arg1 == *arg2);
  1062. }
  1063.  
  1064. long
  1065. float48ne(arg1, arg2)
  1066.     float32    arg1;
  1067.     float64    arg2;
  1068. {
  1069.     if (!arg1 || !arg2)
  1070.         return (long)NULL;
  1071.  
  1072.     return(*arg1 != *arg2);
  1073. }
  1074.  
  1075. long
  1076. float48lt(arg1, arg2)
  1077.     float32    arg1;
  1078.     float64    arg2;
  1079. {
  1080.     if (!arg1 || !arg2)
  1081.         return (long)NULL;
  1082.  
  1083.     return(*arg1 < *arg2);
  1084. }
  1085.  
  1086. long
  1087. float48le(arg1, arg2)
  1088.     float32    arg1;
  1089.     float64    arg2;
  1090. {
  1091.     if (!arg1 || !arg2)
  1092.         return (long)NULL;
  1093.  
  1094.     return(*arg1 <= *arg2);
  1095. }
  1096.  
  1097. long
  1098. float48gt(arg1, arg2)
  1099.     float32    arg1;
  1100.     float64    arg2;
  1101. {
  1102.     if (!arg1 || !arg2)
  1103.         return (long)NULL;
  1104.  
  1105.     return(*arg1 > *arg2);
  1106. }
  1107.  
  1108. long
  1109. float48ge(arg1, arg2)
  1110.     float32    arg1;
  1111.     float64    arg2;
  1112. {
  1113.     if (!arg1 || !arg2)
  1114.         return (long)NULL;
  1115.  
  1116.     return(*arg1 >= *arg2);
  1117. }
  1118.  
  1119. /*
  1120.  *    float84{eq,ne,lt,le,gt,ge}    - float4/float8 comparison operations
  1121.  */
  1122. long
  1123. float84eq(arg1, arg2)
  1124.     float64    arg1;
  1125.     float32    arg2;
  1126. {
  1127.     if (!arg1 || !arg2)
  1128.         return (long)NULL;
  1129.  
  1130.     return(*arg1 == *arg2);
  1131. }
  1132.  
  1133. long
  1134. float84ne(arg1, arg2)
  1135.     float64    arg1;
  1136.     float32    arg2;
  1137. {
  1138.     if (!arg1 || !arg2)
  1139.         return (long)NULL;
  1140.  
  1141.     return(*arg1 != *arg2);
  1142. }
  1143.  
  1144. long
  1145. float84lt(arg1, arg2)
  1146.     float64    arg1;
  1147.     float32    arg2;
  1148. {
  1149.     if (!arg1 || !arg2)
  1150.         return (long)NULL;
  1151.  
  1152.     return(*arg1 < *arg2);
  1153. }
  1154.  
  1155. long
  1156. float84le(arg1, arg2)
  1157.     float64    arg1;
  1158.     float32    arg2;
  1159. {
  1160.     if (!arg1 || !arg2)
  1161.         return (long)NULL;
  1162.  
  1163.     return(*arg1 <= *arg2);
  1164. }
  1165.  
  1166. long
  1167. float84gt(arg1, arg2)
  1168.     float64    arg1;
  1169.     float32    arg2;
  1170. {
  1171.     if (!arg1 || !arg2)
  1172.         return (long)NULL;
  1173.  
  1174.     return(*arg1 > *arg2);
  1175. }
  1176.  
  1177. long
  1178. float84ge(arg1, arg2)
  1179.     float64    arg1;
  1180.     float32    arg2;
  1181. {
  1182.     if (!arg1 || !arg2)
  1183.         return (long)NULL;
  1184.  
  1185.     return(*arg1 >= *arg2);
  1186. }
  1187.  
  1188.  
  1189.  
  1190.          /* ========== PRIVATE ROUTINES ========== */
  1191.  
  1192.                  /* (none) */
  1193.